home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / endo / draw.c < prev    next >
C/C++ Source or Header  |  1995-05-12  |  17KB  |  628 lines
  1. /*************************************************************************
  2.  *                                                                       *
  3.  *  Copyright (c) 1992, 1993 Ronald Joe Record                           *
  4.  *                                                                       *
  5.  *  All rights reserved. No part of this program or publication may be   *
  6.  *  reproduced, transmitted, transcribed, stored in a retrieval system,  *
  7.  *  or translated into any language or computer language, in any form or *
  8.  *  by any means, electronic, mechanical, magnetic, optical, chemical,   *
  9.  *  biological, or otherwise, without the prior written permission of:   *
  10.  *                                                                       *
  11.  *      Ronald Joe Record (408) 458-3718                                 *
  12.  *      212 Owen St., Santa Cruz, California 95062 USA                   *
  13.  *                                                                       *
  14.  *************************************************************************/
  15.  
  16. #include <math.h>
  17. #include <values.h>
  18. #include "x.h"
  19.  
  20. double A=0.05, B=0.85, C=0.1, D=0.95;
  21.  
  22. int orbit_in_basin = 0, orbit_in_precrit = 0, orbit_in_crit = 0;
  23. int see_domain = 0, histex = 0;
  24. double sea_level = 0.0, sky_level = 1.0;
  25. static int hcolor;
  26.  
  27. int
  28. get_hist_index(p)
  29. double p;
  30. {
  31.     extern double pow(), asin();
  32.     extern int start;
  33.     static int m, s;
  34.  
  35.     if ((p < sea_level) || (p > sky_level))
  36.         return(0);
  37.     m = numcolors - start - 1;
  38.     s = start;
  39.     if (histex == 0) /* three segments (0,0)-(A,mB)-(C,mD)-(1,m) */
  40.         if (p < A)
  41.             return((int)(m*B*p/A) + s);
  42.         else if (p < C)
  43.             return((int)((m*(((D-B)*(p-A)/(C-A))+B)))+ s);
  44.         else
  45.             return((int)((m*(1.0-D)*(p-1.0)/(1.0-C))+m) + s);
  46.     if (histex == 1)    /* two lines (0,0)-(A,mB) and (A,mB)-(1,m) */
  47.         if (p < A)
  48.             return((int)(m*B*p/A) + s);
  49.         else
  50.             return((int)(m*(((1.0-B)/(1.0-A)*(p-1.0))+1.0)) + s);
  51.     else if (histex == 2) /* e.g. 256^(1-p) with 0 < p < 1 */
  52.         return((int)(pow((double)m, 1.0 - p)) + s);
  53.     else if (histex == 3)
  54.         return((int)((0.5 + (asin((p*2.0) - 1.0)/M_PI))*m) + s);
  55.     else if (histex == 4) /* two lines (0,0)-(1-A,1-mB) and (1-A,1-mB)-(1,m) */
  56.         if (p < (1.0 - A))
  57.             return((int)(m*(1.0-B)*p/(1.0-A)) + s);
  58.         else
  59.             return((int)(m*((B*(p-1.0)/A)+1.0)) + s);
  60.     else if (histex == -1) /* e.g. 256 - 256^(1-p) with 0 < p < 1 */
  61.         return((int)(m - pow((double)m, 1.0 - p)) + s);
  62.     else if (histex == -2) /* three segments (0,0)-(A,mB)-(1-A,1-mB)-(1,m) */
  63.         if (p < A)
  64.             return((int)(m*B*p/A) + s);
  65.         else if (p < (1.0 - A))
  66.             return((int)(((m-(2.0*m*B))*(p-A)/(1.0-(2.0*A)))+(m*B)) + s);
  67.         else
  68.             return((int)((m*B*(p-1.0)*A)+m) + s);
  69.     else if (histex == -3)    /* reverse linear */
  70.         return((int)(m * (1.0 - p)) + s);
  71.     else                    /* linear */
  72.         return((int)(m * p) + s);
  73. }
  74.  
  75. void
  76. BufferHisto(x, y, n)
  77. int x, y, n;
  78. {
  79.     static int xm, ym, diff;
  80.     static double ncols, power;
  81.     extern int xmargin, ymargin, animate, start, minhist, maxhist;
  82.     extern int **histarray;
  83.  
  84.     if (n == -1) {
  85.         if ((maxhist != 0) && (minhist != MAXINT)) {
  86.             if (maxhist == minhist)
  87.                 diff = 1;
  88.             else
  89.                 diff = maxhist - minhist;
  90.         }
  91.         else
  92.             return;
  93.         ncols = (double)(numcolors - start - 1);
  94.         power = (double)(histarray[x][y] - minhist)/(double)diff;
  95.         hcolor = get_hist_index(power);
  96.     }
  97.     else
  98.         hcolor = n;
  99.     xm = x+xmargin; ym = (traheight-y)+ymargin;
  100.     XDrawPoint(dpy, trajec, Data_GC[hcolor], xm, ym);
  101.     XDrawPoint(dpy, pixtra, Data_GC[hcolor], xm, ym);
  102. }
  103.  
  104. void
  105. draw_precrit(x1,y1,gc)
  106. double x1,y1;
  107. int gc;
  108. {
  109.     static int x2, y2;
  110.  
  111.     if ((x1 > min_x) && (y1 > min_y)) {
  112.         x2 = ((x1 - min_x) / x_range) * (width);
  113.         y2 = ((y1 - min_y) / y_range) * (height);
  114.         if ((x2<width) && (y2<height))
  115.             if (orbit_in_precrit)
  116.                BufferPoint(dpy,prejec,pixpre,Data_GC,&Basins,1,x2,height-y2-1);
  117.             else
  118.                BufferPoint(dpy,prejec,pixpre,Data_GC,&Basins,gc,x2,height-y2-1);
  119.     }
  120. }
  121.  
  122. void
  123. draw_critical(w,x1,y1,gc)
  124. Window w;
  125. double x1,y1;
  126. int gc;
  127. {
  128.     static int x2, y2, wid, hei;
  129.     static Pixmap p;
  130.     static double minx, miny, xr, yr;
  131.  
  132.     if (w == crijec) {
  133.         if (thermometer)
  134.             wid = criwidth - THERMWIDTH;
  135.         else
  136.             wid = criwidth;
  137.         hei = criheight;
  138.         p = pixcri;
  139.         minx = c_min_x;
  140.         miny = c_min_y;
  141.         xr = c_x_range;
  142.         yr = c_y_range;
  143.     }
  144.     else if (w == trajec) {
  145.         if (thermometer)
  146.             wid = trawidth - THERMWIDTH;
  147.         else
  148.             wid = trawidth;
  149.         hei = traheight;
  150.         p = pixtra;
  151.         minx = t_min_x;
  152.         miny = t_min_y;
  153.         xr = t_x_range;
  154.         yr = t_y_range;
  155.     }
  156.     if ((x1 > minx) && (y1 > miny)) {
  157.         x2 = ((x1 - minx) / xr) * (wid);
  158.         y2 = ((y1 - miny) / yr) * (hei);
  159.         if ((x2<wid) && (y2<hei)) {
  160.             if (orbit_in_crit) {
  161.                 XDrawPoint(dpy,w,Data_GC[1],x2,hei-y2-1);
  162.                 XDrawPoint(dpy,p,Data_GC[1],x2,hei-y2-1);
  163.             }
  164.             else {
  165.                 XDrawPoint(dpy,w,Data_GC[gc],x2,hei-y2-1);
  166.                 XDrawPoint(dpy,p,Data_GC[gc],x2,hei-y2-1);
  167.             }
  168.         }
  169.     }
  170. }
  171.  
  172. int
  173. inlevel(n) 
  174. int n;
  175. {
  176.     static int m, M;
  177.     extern int maxhist, minhist;
  178.  
  179.     if (n == 0)
  180.         return(0);
  181.     if ((minhist == MAXINT) || (maxhist == 0))
  182.         return(1);
  183.     m = Max(1, (sea_level * (maxhist - minhist)) + minhist - 1);
  184.     M = (sky_level * (maxhist - minhist)) + minhist + 1;
  185.     if ((n >= m) && (n <= M))
  186.         return(1);
  187.     else
  188.         return(0);
  189. }
  190.  
  191. void
  192. draw_portrait(x1,y1,gc)
  193. double x1,y1;
  194. int gc;
  195. {
  196.     static xy_t p;
  197.     static int bar, twid, cwid;
  198.     extern int xmargin, ymargin, orbits_1d, cornerbar;
  199. #ifdef NorthSouth
  200.     extern double O_B_zero, O_B_one, B_zero, B_one, singularity;
  201.     extern double O_S_B_zero, O_S_B_one, S_B_zero, S_B_one;
  202.     extern double S_singularity;
  203. #endif
  204.     extern int **histarray;
  205.     extern int minhist, maxhist, updt;
  206. #ifdef USE_3D
  207.     extern int plot();
  208.     extern void updtbar();
  209.     extern double window_distance;
  210.     triple xyz;
  211.  
  212.     if (orbits_3d && lyap) {
  213.         xyz.x = x1;
  214.         xyz.y = y1;
  215.         xyz.z = (((params[p1]-min_x)/x_range) * 
  216.             (2.0 * window_distance)) - window_distance;
  217.         if (plot( xyz, &p));
  218.             BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  219.                             gc, p.x + xmargin, (traheight-p.y) + ymargin);
  220.     }
  221.     else {
  222. #endif
  223.         if (thermometer) {
  224.             twid = trawidth - THERMWIDTH;
  225.             cwid = criwidth - THERMWIDTH;
  226.         }
  227.         else {
  228.             twid = trawidth;
  229.             cwid = criwidth;
  230.         }
  231.         if (lyap && orbits_1d) {
  232.             p.x=(((params[p1]-min_x)/x_range) * (double)twid); 
  233. #ifdef NorthSouth
  234.         if (mapindex == 7) {
  235.             if ((orbits_1d < 3) && (see_domain)) {
  236.                 p.y=(int)(((B_zero-t_min_y)/t_y_range) * (double)traheight);
  237.                 if ((p.x<twid) && (p.y>0))
  238.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  239.                                     2,p.x+xmargin,(traheight-p.y)+ymargin);
  240.                 p.y=(int)((((B_one+B_zero)-t_min_y)/t_y_range) * 
  241.                         (double)traheight);
  242.                 if ((p.x<twid) && (p.y>0))
  243.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  244.                                     2,p.x+xmargin,(traheight-p.y)+ymargin);
  245.                 p.y=(int)(((O_B_zero-t_min_y)/t_y_range) * 
  246.                         (double)traheight);
  247.                 if ((p.x<twid) && (p.y>0))
  248.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  249.                                     6,p.x+xmargin,(traheight-p.y)+ymargin);
  250.                 p.y=(int)((((O_B_one+O_B_zero)-t_min_y)/t_y_range) * 
  251.                         (double)traheight);
  252.                 if ((p.x<twid) && (p.y>0))
  253.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  254.                                     6,p.x+xmargin,(traheight-p.y)+ymargin);
  255.                 p.y=(int)(((singularity-t_min_y)/t_y_range) * 
  256.                         (double)traheight);
  257.                 if ((p.x<twid) && (p.y>0))
  258.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  259.                                     1,p.x+xmargin,(traheight-p.y)+ymargin);
  260.             }
  261.             if ((orbits_1d > 1) && (see_domain)) {
  262.                 p.y=(int)(((S_B_zero-t_min_y)/t_y_range)*(double)traheight);
  263.                 if ((p.x<twid) && (p.y>0))
  264.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  265.                                     2,p.x+xmargin,(traheight-p.y)+ymargin);
  266.                 p.y=(int)((((S_B_one+S_B_zero)-t_min_y)/t_y_range) * 
  267.                         (double)traheight);
  268.                 if ((p.x<twid) && (p.y>0))
  269.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  270.                                     2,p.x+xmargin,(traheight-p.y)+ymargin);
  271.                 p.y=(int)(((O_S_B_zero-t_min_y)/t_y_range) * 
  272.                         (double)traheight);
  273.                 if ((p.x<twid) && (p.y>0))
  274.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  275.                                     6,p.x+xmargin,(traheight-p.y)+ymargin);
  276.                 p.y=(int)((((O_S_B_one+O_S_B_zero)-t_min_y)/t_y_range) * 
  277.                         (double)traheight);
  278.                 if ((p.x<twid) && (p.y>0))
  279.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  280.                                     6,p.x+xmargin,(traheight-p.y)+ymargin);
  281.                 p.y=(int)(((S_singularity-t_min_y)/t_y_range) * 
  282.                         (double)traheight);
  283.                 if ((p.x<twid) && (p.y>0))
  284.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  285.                                     1,p.x+xmargin,(traheight-p.y)+ymargin);
  286.             }
  287.         }
  288. #endif /* NorthSouth */
  289.         if (orbits_1d < 3) {
  290.             if (x1 > t_min_x)
  291.                 p.y=(int)(((x1-t_min_x)/t_x_range) * (double)traheight);
  292.             if ((p.x<twid) && (p.y<traheight))
  293.                 if (histogram) {
  294.                     bar = 0;
  295.                     histarray[p.x][p.y]++;
  296.                     if (histarray[p.x][p.y] > maxhist) {
  297.                         maxhist = histarray[p.x][p.y];
  298.                         bar = 1;
  299.                     }
  300.                     if (histarray[p.x][p.y] < minhist) {
  301.                         minhist = histarray[p.x][p.y];
  302.                         bar = 1;
  303.                     }
  304.                     if (inlevel(histarray[p.x][p.y]))
  305.                         BufferHisto(p.x, p.y,-1);
  306.                 }
  307.                 else
  308.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  309.                                     gc,p.x+xmargin,(traheight-p.y)+ymargin);
  310.         }
  311.         if (orbits_1d > 1) {
  312.             if (y1 > t_min_y)
  313.                 p.y=(int)(((y1-t_min_y)/t_y_range) * (double)traheight);
  314.             if ((p.x<twid) && (p.y<traheight))
  315.                 if (histogram) {
  316.                     bar = 0;
  317.                     histarray[p.x][p.y]++;
  318.                     if (histarray[p.x][p.y] > maxhist) {
  319.                         maxhist = histarray[p.x][p.y];
  320.                         bar = 1;
  321.                     }
  322.                     if (histarray[p.x][p.y] < minhist) {
  323.                         minhist = histarray[p.x][p.y];
  324.                         bar = 1;
  325.                     }
  326.                     if (inlevel(histarray[p.x][p.y]))
  327.                         BufferHisto(p.x, p.y,-1);
  328.                 }
  329.                 else
  330.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  331.                                     gc,p.x+xmargin,(traheight-p.y)+ymargin);
  332.             }
  333.          }
  334.          else if (orbits_1d % 2) {
  335.             p.x=(((x-min_x)/x_range) * (double)twid); 
  336.             p.y=(int)(((x1-t_min_x)/t_x_range) * (double)traheight);
  337.             if ((p.x<twid) && (p.y<traheight))
  338.                 if (histogram) {
  339.                     bar = 0;
  340.                     histarray[p.x][p.y]++;
  341.                     if (histarray[p.x][p.y] > maxhist) {
  342.                         maxhist = histarray[p.x][p.y];
  343.                         bar = 1;
  344.                     }
  345.                     if (histarray[p.x][p.y] < minhist) {
  346.                         minhist = histarray[p.x][p.y];
  347.                         bar = 1;
  348.                     }
  349.                      if (inlevel(histarray[p.x][p.y]))
  350.                         BufferHisto(p.x, p.y,-1);
  351.                 }
  352.                 else
  353.                     if (p.y > 0)
  354.                         BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  355.                                         gc,p.x+xmargin,(traheight-p.y)+ymargin);
  356.              }
  357.              else {
  358.                 if ((x1 > t_min_x) && (y1 > t_min_y)) {
  359.                     p.x=(int)(((x1-t_min_x)/t_x_range) * (double)twid);
  360.                     p.y=(int)(((y1-t_min_y)/t_y_range) * (double)traheight);
  361.                 }
  362.             if ((p.x<twid) && (p.y<traheight))
  363.                 if (histogram) {
  364.                     bar = 0;
  365.                     histarray[p.x][p.y]++;
  366.                     if (histarray[p.x][p.y] > maxhist) {
  367.                         maxhist = histarray[p.x][p.y];
  368.                         bar = 1;
  369.                     }
  370.                     if (histarray[p.x][p.y] < minhist) {
  371.                         minhist = histarray[p.x][p.y];
  372.                         bar = 1;
  373.                     }
  374.                      if (inlevel(histarray[p.x][p.y]))
  375.                         BufferHisto(p.x, p.y,-1);
  376.                 }
  377.                 else
  378.                     BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  379.                                     gc, p.x+xmargin, (traheight-p.y) + ymargin);
  380.             if (!histogram) hcolor = gc;
  381.             if (orbit_in_basin) {
  382.                 if ((x1 > min_x) && (y1 > min_y)) {
  383.                     p.x=(int)(((x1-min_x)/x_range) * (double)width);
  384.                     p.y=(int)(((y1-min_y)/y_range) * (double)height);
  385.                 }
  386.                 if ((p.x<width) && (p.y<height)) {
  387.                     XDrawPoint(dpy,canvas,Data_GC[hcolor],p.x,height - p.y);
  388.                     XDrawPoint(dpy,pixmap,Data_GC[hcolor],p.x,height - p.y);
  389.                 }
  390.             }
  391.             if (orbit_in_precrit) {
  392.                 if ((x1 > min_x) && (y1 > min_y)) {
  393.                     p.x=(int)(((x1-min_x)/x_range) * (double)width);
  394.                     p.y=(int)(((y1-min_y)/y_range) * (double)height);
  395.                 }
  396.                 if ((p.x<width) && (p.y<height)) {
  397.                     XDrawPoint(dpy,prejec,Data_GC[hcolor],p.x,height - p.y);
  398.                     XDrawPoint(dpy,pixpre,Data_GC[hcolor],p.x,height - p.y);
  399.                 }
  400.             }
  401.             if (orbit_in_crit) {
  402.                 if ((x1 > c_min_x) && (y1 > c_min_y)) {
  403.                     p.x=(int)(((x1-c_min_x)/c_x_range) * (double)cwid);
  404.                     p.y=(int)(((y1-c_min_y)/c_y_range) * (double)criheight);
  405.                 }
  406.                 if ((p.x<cwid) && (p.y<criheight)) {
  407.                     XDrawPoint(dpy,crijec,Data_GC[hcolor],p.x,criheight-p.y);
  408.                     XDrawPoint(dpy,pixcri,Data_GC[hcolor],p.x,criheight-p.y);
  409.                 }
  410.             }
  411.          }
  412. #ifdef USE_3D
  413.     }
  414. #endif
  415.     if (bar && updt) {
  416.         if (showbar == 1) {
  417.           if (portrait && histogram)
  418.             updtbar(hisbar,HISBARHGT,HISBARHGT,cornerbar,maxhist,minhist);
  419.           else
  420.             updtbar(hisbar,HISBARHGT,HISBARHGT,cornerbar,maxperiod,minperiod);
  421.         }
  422.         else if (showbar == 2) {
  423.           if (portrait && histogram)
  424.             updtbar(trajec,traheight/2,traheight,cornerbar,maxhist,minhist);
  425.           else
  426.             updtbar(trajec,traheight/2,traheight,cornerbar,maxperiod,minperiod);
  427.         }
  428.     }
  429. }
  430.  
  431. void Draw_Diagonal(w)
  432. Window w;
  433. {
  434.     static double x, mix, miy, xrng, yrng;
  435.     static int i, p, q, wid, hei;
  436.  
  437.     if (w == trajec) {
  438.         if (thermometer)
  439.             wid = trawidth - THERMWIDTH;
  440.         else
  441.             wid = trawidth; 
  442.         hei = traheight;
  443.         mix = t_min_x; miy = t_min_y;
  444.         xrng = t_x_range; yrng = t_y_range;
  445.     }
  446.     else if (w == crijec) {
  447.         if (thermometer)
  448.             wid = criwidth - THERMWIDTH;
  449.         else
  450.             wid = criwidth; 
  451.         hei = criheight;
  452.         mix = c_min_x; miy = c_min_y;
  453.         xrng = c_x_range; yrng = c_y_range;
  454.     }
  455.     else {
  456.         wid = width; hei = height;
  457.         mix = min_x; miy = min_y;
  458.         xrng = x_range; yrng = y_range;
  459.     }
  460.     for (i=0; i<wid; i++) {
  461.         x = mix + (((double)i/(double)wid)*xrng);
  462.         p=(int)(((x - mix)/xrng) * (double)wid);
  463.         q=(int)(((x - miy)/yrng) * (double)hei);
  464.         if ((p<wid) && (q<hei))
  465.             XDrawPoint(dpy, w, RubberGC, p, hei - q);
  466.     }
  467. }
  468.  
  469. void
  470. Draw_Axes(w, on)
  471. Window w;
  472. int on;
  473. {
  474.     static double r, mix, miy, xrng, yrng;
  475.     static int i, m, n, wid, hei;
  476.     static xy_t p;
  477. #ifdef USE_3D
  478.     extern int plot();
  479.     extern double window_distance;
  480.     triple xyz;
  481.  
  482.     if (thermometer)
  483.         wid = trawidth - THERMWIDTH;
  484.     else
  485.         wid = trawidth;
  486.     if (orbits_3d && lyap) {
  487.         for (i=0; i<wid; i++) {
  488.             xyz.x = t_min_x+(((double)i/(double)wid)*t_x_range);
  489.             xyz.y = 0;
  490.             xyz.z = 0;
  491.             if (plot( xyz, &p));
  492.                 BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  493.                                 on, p.x, (traheight-p.y));
  494.         }
  495.         for (i=0; i<traheight; i++) {
  496.             xyz.y = t_min_y+(((double)i/(double)traheight)*t_y_range);
  497.             xyz.x = 0;
  498.             xyz.z = 0;
  499.             if (plot( xyz, &p));
  500.                 BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  501.                                 on, p.x, (traheight-p.y));
  502.         }
  503.         for (i=0; i<traheight; i++) {
  504.             xyz.z = ((double)i/(double)traheight) * 2.0 * max_x;
  505.             xyz.x = 0;
  506.             xyz.y = 0;
  507.             if (plot( xyz, &p));
  508.                 BufferPoint(dpy,trajec,pixtra,Data_GC,&Orbits,
  509.                                 on, p.x, (traheight-p.y));
  510.         }
  511.     }
  512.     else {
  513. #endif
  514.         if (w == trajec) {
  515.             if (thermometer)
  516.                 wid = trawidth - THERMWIDTH;
  517.             else
  518.                 wid = trawidth; 
  519.             hei = traheight;
  520.             mix = t_min_x; miy = t_min_y;
  521.             xrng = t_x_range; yrng = t_y_range;
  522.         }
  523.         else if (w == crijec) {
  524.             if (thermometer)
  525.                 wid = criwidth - THERMWIDTH;
  526.             else
  527.                 wid = criwidth; 
  528.             hei = criheight;
  529.             mix = c_min_x; miy = c_min_y;
  530.             xrng = c_x_range; yrng = c_y_range;
  531.         }
  532.         else {
  533.             wid = width; hei = height;
  534.             mix = min_x; miy = min_y;
  535.             xrng = x_range; yrng = y_range;
  536.         }
  537.         for (i=0; i<wid; i++) {
  538.             r = mix + (((double)i/(double)wid)*xrng);
  539.             m=(int)(((r - mix)/xrng) * (double)wid);
  540.             n=(int)(((0.0 - miy)/yrng) * (double)hei);
  541.             if ((m<wid) && (n<hei))
  542.                 XDrawPoint(dpy, w, RubberGC, m, hei - n);
  543.         }
  544.         for (i=0; i<hei; i++) {
  545.             r = miy + (((double)i/(double)hei)*yrng);
  546.             m=(int)(((r - miy)/yrng) * (double)hei);
  547.             n=(int)(((0.0 - mix)/xrng) * (double)wid);
  548.             if ((n<wid) && (m<hei))
  549.                 XDrawPoint(dpy, w, RubberGC, n, m);
  550.         }
  551. #ifdef USE_3D
  552.     }
  553. #endif
  554.     FlushBuffer(dpy,trajec,pixtra,Data_GC,&Orbits,on,on+1);
  555. }
  556.  
  557. void
  558. Redraw_Hist()
  559. {
  560.     static int color, i, j, diff, twid;
  561.     static double ncols, power;
  562.     extern int **histarray;
  563.     extern int xmargin, ymargin, minhist, maxhist, start, cornerbar;
  564.     extern void fillbar();
  565.  
  566.     maxhist = 0; minhist = MAXINT;
  567.     if (thermometer)
  568.         twid = trawidth - THERMWIDTH;
  569.     else
  570.         twid = trawidth;
  571.     for (i=0; i< traheight; i++)
  572.         for (j=0; j< twid; j++)
  573.             if (histarray[j][i]) {
  574.                 maxhist = Max(histarray[j][i], maxhist);
  575.                 minhist = Min(histarray[j][i], minhist);
  576.             }
  577.     if ((minhist == MAXINT) || (maxhist == 0))
  578.         return;
  579.     else if (maxhist == minhist)
  580.         diff = 1;
  581.     else
  582.         diff = maxhist - minhist;
  583.     for (i = 0 ; i < MAXCOLOR; ++i)
  584.         Histog.npoints[i] = 0;
  585.     ncols = (double)(numcolors - start - 1);
  586.     for (i=0; i< traheight; i++)
  587.         for (j=0; j< twid; j++) {
  588.             if (histarray[j][i]) {
  589.                 power = (double)(histarray[j][i] - minhist)/(double)diff;
  590.                 color = get_hist_index(power);
  591.             }
  592.             else
  593.                 color = 0;
  594.             if (Histog.npoints[color] == MAXPOINTS) {
  595.                 XDrawPoints(dpy, trajec, Data_GC[color], Histog.data[color],
  596.                     Histog.npoints[color], CoordModeOrigin);
  597.                 XDrawPoints(dpy, pixtra, Data_GC[color], Histog.data[color],
  598.                     Histog.npoints[color], CoordModeOrigin);
  599.                 Histog.npoints[color] = 0;
  600.             }
  601.             Histog.data[color][Histog.npoints[color]].x = j + xmargin;
  602.             Histog.data[color][Histog.npoints[color]].y = 
  603.                 (traheight - i) + ymargin;
  604.             ++Histog.npoints[color];
  605.         }
  606.     FlushBuffer(dpy,trajec,pixtra,Data_GC,&Histog,0,numcolors);
  607.     if (showbar == 1)
  608.         fillbar(hisbar, HISBARHGT, HISBARHGT, cornerbar);
  609.     else if (showbar == 2)
  610.         fillbar(trajec, traheight/2, traheight, cornerbar);
  611. }
  612.  
  613. void
  614. AllFlushBuffer() {
  615.     FlushBuffer(dpy, which, pixmap, Data_GC, &Points, 0, numcolors);
  616.     FlushBuffer(dpy, trajec, pixtra, Data_GC, &Orbits, 0, numcolors);
  617.     FlushBuffer(dpy, prejec, pixpre, Data_GC, &Basins, 0, numcolors);
  618.     FlushBuffer(dpy, trajec, pixtra, Data_GC, &Histog, 0, numcolors);
  619. }
  620.  
  621. void
  622. AllInitBuffer() {
  623.     InitBuffer(&Points, MAXCOLOR);
  624.     InitBuffer(&Orbits, MAXCOLOR);
  625.     InitBuffer(&Basins, MAXCOLOR);
  626.     InitBuffer(&Histog, MAXCOLOR);
  627. }
  628.